// const bcrypt = require('bcryptjs');
// const jwt = require('jsonwebtoken');
// const UserModel = require('../models/userModel');

// // 新增：生成指定城市范围内的随机经纬度
// const getRandomLocation = (city = 'beijing') => {
//   // 定义主要城市的经纬度范围（确保生成的位置在真实城市区域内）
//   const cityCoordinates = {
//     beijing: { lat: [39.7, 40.2], lng: [116.1, 116.7] },    // 北京
//     shanghai: { lat: [30.8, 31.4], lng: [121.2, 121.8] },   // 上海
//     guangzhou: { lat: [22.8, 23.2], lng: [113.1, 113.9] },  // 广州
//     shenzhen: { lat: [22.4, 22.8], lng: [113.7, 114.6] }    // 深圳
//   };

//   // 随机选择一个城市（如果未指定）
//   const targetCity = cityCoordinates[city] 
//     ? city 
//     : Object.keys(cityCoordinates)[Math.floor(Math.random() * Object.keys(cityCoordinates).length)];
  
//   const { lat: latRange, lng: lngRange } = cityCoordinates[targetCity];
  
//   // 生成范围内的随机经纬度（保留6位小数，精度约10厘米）
//   const latitude = parseFloat((latRange[0] + Math.random() * (latRange[1] - latRange[0])).toFixed(6));
//   const longitude = parseFloat((lngRange[0] + Math.random() * (lngRange[1] - lngRange[0])).toFixed(6));

//   return {
//     latitude,
//     longitude,
//     city: targetCity // 返回城市标识，方便前端显示
//   };
// };

// // 生成JWT令牌（修改：添加位置信息）
// const generateToken = (userId, phone, location) => {
//   return jwt.sign(
//     { 
//       id: userId, 
//       phone,
//       // 新增：将位置信息存入Token
//       latitude: location.latitude,
//       longitude: location.longitude,
//       city: location.city
//     },
//     process.env.JWT_SECRET,
//     { expiresIn: '7d' } // 7天有效期
//   );
// };

// // 用户注册
// exports.register = async (req, res) => {
//   try {
//     const { phone, password, nickname } = req.body;
    
//     // 验证参数
//     if (!phone || !password) {
//       return res.status(400).json({ message: '手机号和密码不能为空' });
//     }
    
//     // 检查用户是否已存在
//     const existingUser = await UserModel.findByPhone(phone);
//     if (existingUser) {
//       return res.status(400).json({ message: '该手机号已被注册' });
//     }
    
//     // 密码加密
//     const salt = await bcrypt.genSalt(10);
//     const hashedPassword = await bcrypt.hash(password, salt);
    
//     // 创建用户
//     const userId = await UserModel.create({
//       phone,
//       password: hashedPassword,
//       nickname
//     });
    
//     // 获取创建的用户
//     const user = await UserModel.findById(userId);
    
//     // 新增：为新用户生成随机位置
//     const location = getRandomLocation();
    
//     // 生成令牌（传入位置信息）
//     const token = generateToken(userId, phone, location);
    
//     res.status(201).json({
//       message: '注册成功',
//       token,
//       user: {
//         ...user,
//         // 新增：返回用户位置信息
//         location: {
//           latitude: location.latitude,
//           longitude: location.longitude,
//           city: location.city === 'beijing' ? '北京' : 
//                 location.city === 'shanghai' ? '上海' :
//                 location.city === 'guangzhou' ? '广州' : '深圳'
//         }
//       }
//     });
//   } catch (error) {
//     res.status(500).json({ message: '服务器错误', error: error.message });
//   }
// };

// // 用户登录（修改：添加随机位置生成）
// exports.login = async (req, res) => {
//   try {
//     const { phone, password } = req.body;
    
//     // 验证参数
//     if (!phone || !password) {
//       return res.status(400).json({ message: '手机号和密码不能为空' });
//     }
    
//     // 查找用户
//     const user = await UserModel.findByPhone(phone);
//     if (!user) {
//       return res.status(401).json({ message: '用户不存在' });
//     }
    
//     // 验证密码
//     const isPasswordValid = await bcrypt.compare(password, user.password);
//     if (!isPasswordValid) {
//       return res.status(401).json({ message: '密码错误' });
//     }
    
//     // 新增：生成随机位置（每次登录可能获取不同位置）
//     const location = getRandomLocation();
    
//     // 生成令牌（传入位置信息）
//     const token = generateToken(user.id, phone, location);
    
//     // 返回用户信息（包含位置信息）
//     const userInfo = {
//       id: user.id,
//       phone: user.phone,
//       nickname: user.nickname,
//       avatar: user.avatar,
//       // 新增：返回位置信息给前端
//       location: {
//         latitude: location.latitude,
//         longitude: location.longitude,
//         city: location.city === 'beijing' ? '北京' : 
//               location.city === 'shanghai' ? '上海' :
//               location.city === 'guangzhou' ? '广州' : '深圳'
//       }
//     };
    
//     res.json({
//       message: '登录成功',
//       token,
//       user: userInfo
//     });
//   } catch (error) {
//     res.status(500).json({ message: '服务器错误', error: error.message });
//   }
// };

// // 获取当前登录用户信息（修改：添加位置信息）
// exports.getCurrentUser = async (req, res) => {
//   try {
//     // req.user由auth中间件设置，包含位置信息
//     res.json({ 
//       user: {
//         ...req.user,
//         // 补充城市名称显示
//         location: req.user.city ? {
//           latitude: req.user.latitude,
//           longitude: req.user.longitude,
//           city: req.user.city === 'beijing' ? '北京' : 
//                 req.user.city === 'shanghai' ? '上海' :
//                 req.user.city === 'guangzhou' ? '广州' : '深圳'
//         } : null
//       } 
//     });
//   } catch (error) {
//     res.status(500).json({ message: '服务器错误', error: error.message });
//   }
// };

//userController.js
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const UserModel = require('../models/userModel');

// 新增：生成指定城市范围内的随机经纬度
const getRandomLocation = (city = 'beijing') => {
  // 定义主要城市的经纬度范围（确保生成的位置在真实城市区域内）
  const cityCoordinates = {
    beijing: { lat: [39.7, 40.2], lng: [116.1, 116.7] },    // 北京
    shanghai: { lat: [30.8, 31.4], lng: [121.2, 121.8] },   // 上海
    guangzhou: { lat: [22.8, 23.2], lng: [113.1, 113.9] },  // 广州
    shenzhen: { lat: [22.4, 22.8], lng: [113.7, 114.6] }    // 深圳
  };

  // 随机选择一个城市（如果未指定）
  const targetCity = cityCoordinates[city]
    ? city
    : Object.keys(cityCoordinates)[Math.floor(Math.random() * Object.keys(cityCoordinates).length)];

  const { lat: latRange, lng: lngRange } = cityCoordinates[targetCity];

  // 生成范围内的随机经纬度（保留6位小数，精度约10厘米）
  const latitude = parseFloat((latRange[0] + Math.random() * (latRange[1] - latRange[0])).toFixed(6));
  const longitude = parseFloat((lngRange[0] + Math.random() * (lngRange[1] - lngRange[0])).toFixed(6));

  return {
    latitude,
    longitude,
    city: targetCity // 返回城市标识，方便前端显示
  };
};

// 生成JWT令牌（修改：添加位置信息）
const generateToken = (userId, phone, location) => {
  return jwt.sign(
    {
      id: userId,
      phone,
      // 新增：将位置信息存入Token
      latitude: location.latitude,
      longitude: location.longitude,
      city: location.city
    },
    process.env.JWT_SECRET,
    { expiresIn: '7d' } // 7天有效期
  );
};

// 用户注册
exports.register = async (req, res) => {
  try {
    const { phone, password, nickname } = req.body;

    // 验证参数
    if (!phone || !password) {
      return res.status(400).json({ message: '手机号和密码不能为空' });
    }

    // 检查用户是否已存在
    const existingUser = await UserModel.findByPhone(phone);
    if (existingUser) {
      return res.status(400).json({ message: '该手机号已被注册' });
    }

    // 密码加密
    const salt = await bcrypt.genSalt(10);
    const hashedPassword = await bcrypt.hash(password, salt);

    // 创建用户
    const userId = await UserModel.create({
      phone,
      password: hashedPassword,
      nickname
    });

    // 获取创建的用户
    const user = await UserModel.findById(userId);

    // 新增：为新用户生成随机位置
    const location = getRandomLocation();

    // 生成令牌（传入位置信息）
    const token = generateToken(userId, phone, location);

    res.status(201).json({
      message: '注册成功',
      token,
      user: {
        ...user,
        // 新增：返回用户位置信息
        location: {
          latitude: location.latitude,
          longitude: location.longitude,
          city: location.city === 'beijing' ? '北京' :
            location.city === 'shanghai' ? '上海' :
              location.city === 'guangzhou' ? '广州' : '深圳'
        }
      }
    });
  } catch (error) {
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
};

// 用户登录（修改：添加随机位置生成）
exports.login = async (req, res) => {
  try {
    const { phone, password } = req.body;

    // 验证参数
    if (!phone || !password) {
      return res.status(400).json({ message: '手机号和密码不能为空' });
    }

    // 查找用户
    const user = await UserModel.findByPhone(phone);
    if (!user) {
      return res.status(401).json({ message: '用户不存在' });
    }

    // 验证密码
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      return res.status(401).json({ message: '密码错误' });
    }

    // 新增：生成随机位置（每次登录可能获取不同位置）
    const location = getRandomLocation();

    // 生成令牌（传入位置信息）
    const token = generateToken(user.id, phone, location);

    // 返回用户信息（包含位置信息）
    const userInfo = {
      id: user.id,
      phone: user.phone,
      nickname: user.nickname,
      avatar: user.avatar,
      // 新增：返回位置信息给前端
      location: {
        latitude: location.latitude,
        longitude: location.longitude,
        city: location.city === 'beijing' ? '北京' :
          location.city === 'shanghai' ? '上海' :
            location.city === 'guangzhou' ? '广州' : '深圳'
      }
    };

    res.json({
      message: '登录成功',
      token,
      user: userInfo
    });
  } catch (error) {
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
};

// 获取当前登录用户信息
exports.getCurrentUser = async (req, res) => {
  try {
    // 构建用户响应对象
    const userResponse = { ...req.user };

    // 添加格式化后的位置信息
    if (req.user.city) {
      userResponse.location = {
        latitude: req.user.latitude,
        longitude: req.user.longitude,
        city: req.user.city === 'beijing' ? '北京' :
          req.user.city === 'shanghai' ? '上海' :
            req.user.city === 'guangzhou' ? '广州' : '深圳'
      };
    }

    // 移除原始的位置坐标字段（可选）
    delete userResponse.latitude;
    delete userResponse.longitude;
    delete userResponse.city;

    res.json({
      user: userResponse
    });
  } catch (error) {
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
};

// 在 userController.js 中添加更新个人信息方法
exports.updateProfile = async (req, res) => {
  try {
    const userId = req.user.id;
    const { nickname, avatar } = req.body;

    // 验证参数
    if (!nickname || nickname.trim() === '') {
      return res.status(400).json({ message: '昵称不能为空' });
    }

    // 使用 UserModel 的 update 方法
    const updated = await UserModel.update(userId, {
      nickname: nickname.trim(),
      avatar: avatar
    });

    if (!updated) {
      return res.status(404).json({ message: '用户不存在' });
    }

    // 获取更新后的用户信息
    const updatedUser = await UserModel.findById(userId);

    res.json({
      message: '个人信息更新成功',
      user: updatedUser
    });

  } catch (error) {
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
};